home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / program / funnel.zoo / sources / analyse.c next >
C/C++ Source or Header  |  1993-04-11  |  12KB  |  297 lines
  1. /*##############################################################################
  2.  
  3. FUNNNELWEB COPYRIGHT
  4. ====================
  5. FunnelWeb is a literate-programming macro preprocessor.
  6.  
  7. Copyright (C) 1992 Ross N. Williams.
  8.  
  9.    Ross N. Williams
  10.    ross@spam.adelaide.edu.au
  11.    16 Lerwick Avenue, Hazelwood Park 5066, Australia.
  12.  
  13. This program is free software; you can redistribute it and/or modify
  14. it under the terms of Version 2 of the GNU General Public License as
  15. published by the Free Software Foundation.
  16.  
  17. This program is distributed WITHOUT ANY WARRANTY; without even the implied
  18. warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  19. See Version 2 of the GNU General Public License for more details.
  20.  
  21. You should have received a copy of Version 2 of the GNU General Public
  22. License along with this program. If not, you can FTP the license from
  23. prep.ai.mit.edu/pub/gnu/COPYING-2 or write to the Free Software
  24. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  25.  
  26. Section 2a of the license requires that all changes to this file be
  27. recorded prominently in this file. Please record all changes here.
  28.  
  29. Programmers:
  30.    RNW  Ross N. Williams  ross@spam.adelaide.edu.au
  31.  
  32. Changes:
  33.    07-May-1992  RNW  Program prepared for release under GNU GPL V2.
  34.  
  35. ##############################################################################*/
  36.  
  37.  
  38. /******************************************************************************/
  39. /*                                   ANALYSE.C                                */
  40. /******************************************************************************/
  41.  
  42. #include "style.h"
  43.  
  44. #include "analyse.h"
  45. #include "as.h"
  46. #include "data.h"
  47. #include "lister.h"
  48. #include "misc.h"
  49. #include "table.h"
  50.  
  51. /******************************************************************************/
  52.  
  53. LOCAL void chk_mac P_((p_ma_t));
  54. LOCAL void chk_mac (p_ma)
  55. p_ma_t p_ma;
  56. {
  57.  mc_t *call;
  58.  
  59.  /* Deal with undefined macros by flagging the first invocation. */
  60.  if (!p_ma->ma_defn.md_isdef)
  61.    {
  62.     ls_loo(p_ma->ma_calls,(ulong) 1,PPV &call);
  63.     as_cold(call!=NULL,"check_macro: No instances of \"undefined\" macro!");
  64.     lr_err(&call->mc_ps,"Call to undefined macro.");
  65.     return;
  66.    }
  67.  
  68.  /* Assert: The macro has a definition. */
  69.  
  70.  /* Check that all the calls to the macro have the correct number of params. */
  71.  ls_fir(p_ma->ma_calls);
  72.  ls_nxt(p_ma->ma_calls,PPV &call);
  73.  while (call!=NULL)
  74.     {
  75.      if (call->mc_npar != p_ma->ma_defn.md_npar)
  76.        {
  77.         sprintf(linet1,"Call has %lu parameter%s, but the macro",
  78.                 (ulong) call->mc_npar,
  79.                 call->mc_npar==1 ? "" : "s");
  80.         lr_err(&(call->mc_ps),linet1);
  81.         sprintf(linet1,"definition at line %lu specifies %lu parameter%s.",
  82.                 (ulong) p_ma->ma_defn.md_ps.ps_line,
  83.                 (ulong) p_ma->ma_defn.md_npar,
  84.                 p_ma->ma_defn.md_npar==1 ? "" : "s");
  85.         lr_mes(&(call->mc_ps),linet1);
  86.         if (p_ma->ma_defn.md_npar==0 && call->mc_npar==1)
  87.           {
  88.            lr_mes(&(call->mc_ps),"Note: If your call looks like this: @<Macro@>@(@) then you");
  89.            lr_mes(&(call->mc_ps),"should be aware that FunnelWeb treats this as a call with");
  90.            lr_mes(&(call->mc_ps),"a single parameter consisting of the empty string. This");
  91.            lr_mes(&(call->mc_ps),"is a consequence of parameter delimiters @\"@\" being optional.");
  92.           }
  93.        }
  94.      ls_nxt(p_ma->ma_calls,PPV &call);
  95.     }
  96.  
  97.  /* Check that the number of calls of the macro is legal. */
  98.  if (p_ma->ma_defn.md_isfil)
  99.    {
  100.     /* Flag all calls to a file macro as errors. */
  101.     if (ls_len(p_ma->ma_calls)>0)
  102.       {
  103.        lr_mes(&p_ma->ma_defn.md_ps,
  104.               "This file macro is called one or more times.");
  105.        lr_mes(&p_ma->ma_defn.md_ps,
  106.               "Each call has been flagged with an error message.");
  107.       }
  108.     ls_fir(p_ma->ma_calls);
  109.     ls_nxt(p_ma->ma_calls,PPV &call);
  110.     while (call!=NULL)
  111.       {
  112.        lr_err(&(call->mc_ps),"Calls to file macros are not allowed.");
  113.        lr_mes(&(call->mc_ps),"Reason: It should be possible to comment out a");
  114.        lr_mes(&(call->mc_ps),"file macro without a big fuss. Calling a file macro");
  115.        lr_mes(&(call->mc_ps),"just tangles it up in the macro structure,");
  116.        lr_mes(&(call->mc_ps),"making it more difficult to comment out later.");
  117.        ls_nxt(p_ma->ma_calls,PPV &call);
  118.       }
  119.    }
  120.  else
  121.    {
  122.     /* Non-file macros. */
  123.     if (ls_len(p_ma->ma_calls)==0 && !p_ma->ma_defn.md_iszer)
  124.        lr_err(&p_ma->ma_defn.md_ps,
  125.               "This macro is never used (and has no @Z).");
  126.  
  127.     if (ls_len(p_ma->ma_calls)>1 && !p_ma->ma_defn.md_isman)
  128.        lr_err(&p_ma->ma_defn.md_ps,
  129.               "This macro is used more than once (and has no @M).");
  130.    }
  131. }
  132.  
  133. /******************************************************************************/
  134.  
  135. LOCAL void chk_rec P_((void));
  136. LOCAL void chk_rec()
  137. /* This macro analyses the calls between the macros in the macro              */
  138. /* table and flags all recursive macros with an error message.                */
  139. /*                                                                            */
  140. /* Def: A macro is a "level 0 macro" if it does not call any macros.          */
  141. /* Def: A macro is a "level n macro" if it calls at least one macro of level  */
  142. /*      n-1, but does not call any macros of level n or higher.               */
  143. /* Def: A macro is a "level infinity macro" if it directly or indirectly      */
  144. /*      calls itself.                                                         */
  145. /*                                                                            */
  146. /* This function totally ignores undefined macros. This means that it can be  */
  147. /* invoked even if problems are detected by the other checks.                 */
  148. /*                                                                            */
  149. /* Although the actions of this may seem rather time expensive, they may not  */
  150. /* be. The function repeatedly runs through the macro table and each macro's  */
  151. /* bodypart list and expression lists. However, there are not likely to be    */
  152. /* many macros and each definition expression list is likely to be quite      */
  153. /* short, as each macro will be mainly text.                                  */
  154. /* Even if this stuff does take a while, it is better to detect recursion now */
  155. /* than at tangle time!                                                       */
  156. {
  157.  p_ma_t p_ma;        /* General purpose pointer to macro.                     */
  158.  name_t dummy_name;  /* Dummy name variable acts as a placeholder in calls.   */
  159.  uword  level;       /* Level of macro currently being tagged.                */
  160.  bool   gotone;      /* TRUE iff current loop iteration tagged >0 macros.     */
  161.  
  162. /* We need a concrete number to stand for level infinity. */
  163. /* 30000 is a nice, large 15 bit number.                  */
  164. #define LEVINF 30000
  165.  
  166.  /* Make sure that our idea of infinity is big enough. */
  167.  as_cold(tb_len(macro_table)<LEVINF,"ana_rec: too many macros.");
  168.  
  169.  /* Tag all the macros as being at level infinity.                            */
  170.  /* This could be done in the parser, but it's neater to do it here.          */
  171.  tb_fir(macro_table);
  172.  while (tb_rea(macro_table,PV dummy_name,PV &p_ma))
  173.     if (p_ma->ma_defn.md_isdef)
  174.        p_ma->ma_level=LEVINF;
  175.  
  176.  gotone=TRUE;
  177.  /* Work from level 0 upwards identifying macros of successive levels.        */
  178.  for (level=0; level<LEVINF && gotone; level++)
  179.    {
  180.     /* Identify all macros of level 'level'. */
  181.     /* Gotone tells us if we managed to tag a macro during this iteration. */
  182.     gotone=FALSE;
  183.  
  184.     /* Run through table tagging all macros at level 'level'. */
  185.     tb_fir(macro_table);
  186.     while (tb_rea(macro_table,PV dummy_name,PV &p_ma))
  187.       {
  188.        if (p_ma->ma_defn.md_isdef && p_ma->ma_level == LEVINF)
  189.          {
  190.           p_bpls_t p_bpls = p_ma->ma_defn.md_body;
  191.           /* Run through each body part of the macro. */
  192.           ls_fir(p_bpls);
  193.           while (TRUE)
  194.